home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_jade.idb / usr / freeware / include / sp / lib / ParserState.h.z / ParserState.h
Encoding:
C/C++ Source or Header  |  1999-07-21  |  17.5 KB  |  844 lines
  1. // Copyright (c) 1994 James Clark
  2. // See the file COPYING for copying permission.
  3.  
  4. #ifndef ParserState_INCLUDED
  5. #define ParserState_INCLUDED 1
  6. #ifdef __GNUG__
  7. #pragma interface
  8. #endif
  9.  
  10. #include <stddef.h>
  11. #include <signal.h>
  12. #include "Allocator.h"
  13. #include "Attribute.h"
  14. #include "Boolean.h"
  15. #include "Vector.h"
  16. #include "StringC.h"
  17. #include "Dtd.h"
  18. #include "Entity.h"
  19. #include "EntityCatalog.h"
  20. #include "EntityManager.h"
  21. #include "Event.h"
  22. #include "EventQueue.h"
  23. #include "Id.h"
  24. #include "InputSource.h"
  25. #include "IList.h"
  26. #include "IQueue.h"
  27. #include "Location.h"
  28. #include "Message.h"
  29. #include "Mode.h"
  30. #include "OpenElement.h"
  31. #include "OutputState.h"
  32. #include "ParserOptions.h"
  33. #include "Ptr.h"
  34. #include "Recognizer.h"
  35. #include "Sd.h"
  36. #include "Syntax.h"
  37. #include "NCVector.h"
  38. #include "Owner.h"
  39. #include "Lpd.h"
  40. #include "LpdEntityRef.h"
  41. #include "Markup.h"
  42. #include "ContentState.h"
  43.  
  44. #ifdef SP_NAMESPACE
  45. namespace SP_NAMESPACE {
  46. #endif
  47.  
  48. class ParserState : public ContentState, public AttributeContext { 
  49. public:
  50.   enum Phase {
  51.     noPhase,
  52.     initPhase,
  53.     prologPhase,
  54.     declSubsetPhase,
  55.     instanceStartPhase,
  56.     contentPhase
  57.     };
  58.   ParserState(const Ptr<EntityManager> &,
  59.           const ParserOptions &,
  60.           unsigned subdocLevel,
  61.           Phase finalPhase);
  62.   void setHandler(EventHandler *, const volatile sig_atomic_t *cancelPtr);
  63.   void unsetHandler();
  64.   Boolean inInstance() const;
  65.   Boolean hadDtd() const;
  66.   void allDone();
  67.   void startDtd(const StringC &);
  68.   void endDtd();
  69.   void startInstance();
  70.   unsigned subdocLevel() const;
  71.   Boolean haveDefLpd() const;
  72.   Dtd &defDtd();
  73.   const Ptr<Dtd> &defDtdPointer() const;
  74.   Boolean haveCurrentDtd() const;
  75.   const Dtd ¤tDtd() const;
  76.   Dtd ¤tDtdNonConst() const;
  77.   const ConstPtr<Dtd> ¤tDtdPointer() const;
  78.   void startLpd(Ptr<Lpd> &lpd);
  79.   void endLpd();
  80.   Lpd &defLpd();
  81.   Ptr<Lpd> &defLpdPointer();
  82.   Ptr<ComplexLpd> defComplexLpdPointer();
  83.   size_t nActiveLink() const;
  84.   const Lpd &activeLpd(size_t i) const;
  85.   ComplexLpd &defComplexLpd();
  86.   Ptr<Dtd> lookupDtd(const StringC &name);
  87.   Ptr<Dtd> baseDtd();
  88.   void activateLinkType(const StringC &);
  89.   void allLinkTypesActivated();
  90.   void setResultAttributeSpecMode();
  91.   void clearResultAttributeSpecMode();
  92.   Boolean haveApplicableDtd() const;
  93.   Boolean hadLpd() const;
  94.   Boolean pass2() const;
  95.   void setPass2Start();
  96.   Boolean maybeStartPass2();
  97.   void checkEntityStability();
  98.   void noteReferencedEntity(const ConstPtr<Entity> &entity,
  99.                 Boolean, Boolean);
  100.   ConstPtr<Lpd> lookupLpd(const StringC &name) const;
  101.   Boolean shouldActivateLink(const StringC &) const;
  102.   Char currentChar() const;
  103.   const Location ¤tLocation() const;
  104.   InputSource *currentInput() const;
  105.   EntityManager &entityManager() const;
  106.   Ptr<EntityManager> entityManagerPtr() const;
  107.   const EntityCatalog &entityCatalog() const;
  108.   ConstPtr<EntityCatalog> entityCatalogPtr() const;
  109.   void setEntityCatalog(const ConstPtr<EntityCatalog> &);
  110.   void setSyntax(ConstPtr<Syntax>);
  111.   void setSyntaxes(ConstPtr<Syntax>, ConstPtr<Syntax>);
  112.   void setSd(ConstPtr<Sd>);
  113.   const Syntax &syntax() const;
  114.   const Syntax &instanceSyntax() const;
  115.   const ConstPtr<Syntax> &syntaxPointer() const;
  116.   const ConstPtr<Syntax> &prologSyntaxPointer() const;
  117.   const ConstPtr<Syntax> &instanceSyntaxPointer() const;
  118.   const Sd &sd() const;
  119.   const ConstPtr<Sd> &sdPointer() const;
  120.   void setPhase(Phase phase);
  121.   Phase phase() const;
  122.   Phase finalPhase() const;
  123.   Mode currentMode() const;
  124.   void setRecognizer(Mode, ConstPtr<Recognizer>);
  125.   void setNormalMap(const XcharMap<PackedBoolean> &);
  126.   const XcharMap<PackedBoolean> &normalMap() const;
  127.   Xchar getChar();
  128.   void skipChar();
  129.   Token getToken(Mode mode);
  130.   StringC currentToken() const;
  131.   void getCurrentToken(StringC &) const;
  132.   void getCurrentToken(const SubstTable<Char> *, StringC &) const;
  133.   unsigned inputLevel() const;
  134.   unsigned specialParseInputLevel() const;
  135.   unsigned markedSectionLevel() const;
  136.   unsigned markedSectionSpecialLevel() const;
  137.   unsigned currentInputElementIndex() const;
  138.   const Location ¤tMarkedSectionStartLocation() const;
  139.   Boolean entityIsOpen(const EntityDecl *) const;
  140.   void popInputStack();
  141.   void pushInput(InputSource *);
  142.   Boolean referenceDsEntity(const Location &);
  143.   void setDsEntity(const ConstPtr<Entity> &);
  144.   Boolean eventQueueEmpty() const;
  145.   Event *eventQueueGet();
  146.   EventHandler &eventHandler();
  147.   void pushElement(OpenElement *);
  148.   OpenElement *popSaveElement();
  149.   void popElement();
  150.   void pcdataRecover();
  151.   Boolean pcdataRecovering() const;
  152.   ConstPtr<Entity> lookupEntity(Boolean isParameter,
  153.                 const StringC &name,
  154.                 const Location &,
  155.                 Boolean referenced);
  156.   ConstPtr<Entity> createUndefinedEntity(const StringC &,
  157.                      const Location &);
  158.   Boolean appendCurrentRank(StringC &, const RankStem *) const;
  159.   void setCurrentRank(const RankStem *, const StringC &);
  160.   void startMarkedSection(const Location &);
  161.   void startSpecialMarkedSection(Mode, const Location &);
  162.   void endMarkedSection();
  163.   void queueRe(const Location &);
  164.   void noteMarkup();
  165.   void noteData();
  166.   void noteRs();
  167.   void noteStartElement(Boolean included);
  168.   void noteEndElement(Boolean included);
  169.   // size of objects allocated with this must not exceed
  170.   // sizeof(StartElementEvent)
  171.   Allocator &eventAllocator();
  172.   // size of objects allocated with this must not exceed
  173.   // sizeof(OpenElement)
  174.   Allocator &internalAllocator();
  175.   AttributeList *allocAttributeList(const ConstPtr<AttributeDefinitionList> &,
  176.                     unsigned i);
  177.  
  178.   static void freeEvent(void *);
  179.   Boolean wantMarkup() const;
  180.   const EventsWanted &eventsWanted() const;
  181.   StringC &nameBuffer();
  182.   typedef NamedTableIter<Id> IdTableIter;
  183.   IdTableIter idTableIter();
  184.   const ParserOptions &options() const;
  185.   void enableImplydef();
  186.   Boolean implydefElement();
  187.   Boolean implydefAttlist();
  188.   void keepMessages();
  189.   void releaseKeptMessages();
  190.   void discardKeptMessages();
  191.   Messenger &messenger();
  192.  
  193.   Markup *currentMarkup();
  194.   const Location &markupLocation() const;
  195.   Markup *startMarkup(Boolean, const Location &);
  196.   void inheritActiveLinkTypes(const ParserState &parent);
  197.   Boolean cancelled() const;
  198.  
  199.   // AFDR extensions
  200.   void setHadAfdrDecl();
  201.   Boolean hadAfdrDecl() const;
  202.  
  203.   // Implementation of AttributeContext.
  204.   Boolean defineId(const StringC &, const Location &, Location &);
  205.   void noteIdref(const StringC &, const Location &);
  206.   void noteCurrentAttribute(size_t, AttributeValue *);
  207.   ConstPtr<AttributeValue> getCurrentAttribute(size_t) const;
  208.   ConstPtr<Entity> getAttributeEntity(const StringC &,
  209.                       const Location &);
  210.   ConstPtr<Notation> getAttributeNotation(const StringC &,
  211.                       const Location &);
  212.   const Syntax &attributeSyntax() const;
  213.  
  214. private:
  215.   ParserState(const ParserState &); // undefined
  216.   void operator=(const ParserState &); // undefined
  217.   void dispatchMessage(Message &);
  218.   void dispatchMessage(const Message &);
  219.   void initMessage(Message &);
  220.   void queueMessage(MessageEvent *);
  221.   Id *lookupCreateId(const StringC &);
  222.  
  223.   ParserOptions options_;
  224.   EventHandler *handler_;
  225.   Pass1EventHandler pass1Handler_;
  226.   Boolean allowPass2_;
  227.   Offset pass2StartOffset_;
  228.   Boolean hadPass2Start_;
  229.   EventQueue eventQueue_;
  230.   OutputState outputState_;
  231.   ConstPtr<Syntax> prologSyntax_;
  232.   ConstPtr<Syntax> instanceSyntax_;
  233.   ConstPtr<Sd> sd_;
  234.   unsigned subdocLevel_;
  235.   Ptr<EntityManager> entityManager_;
  236.   ConstPtr<EntityCatalog> entityCatalog_;
  237.   Phase phase_;
  238.   Phase finalPhase_;
  239.   Boolean inInstance_;
  240.   Ptr<Dtd> defDtd_;
  241.   Ptr<Lpd> defLpd_;
  242.   Vector<ConstPtr<Lpd> > allLpd_;
  243.   Vector<ConstPtr<Lpd> > lpd_; // active LPDs
  244.   Vector<StringC> activeLinkTypes_;
  245.   Boolean activeLinkTypesSubsted_;
  246.   Boolean hadLpd_;
  247.   Boolean resultAttributeSpecMode_;
  248.   Boolean pass2_;
  249.   typedef OwnerTable<LpdEntityRef, LpdEntityRef, LpdEntityRef, LpdEntityRef>
  250.     LpdEntityRefSet;
  251.   typedef OwnerTableIter<LpdEntityRef, LpdEntityRef, LpdEntityRef, LpdEntityRef>
  252.     LpdEntityRefSetIter;
  253.   LpdEntityRefSet lpdEntityRefs_;
  254.   // external entity to be referenced at the end of the declaration subset
  255.   ConstPtr<Entity> dsEntity_;
  256.   Allocator eventAllocator_;
  257.   Allocator internalAllocator_;
  258.   NCVector<Owner<AttributeList> > attributeLists_;
  259.   StringC nameBuffer_;
  260.   Boolean keepingMessages_;
  261.   IQueue<MessageEvent> keptMessages_;
  262.   Mode currentMode_;
  263.   Boolean pcdataRecovering_;
  264.   // if in a special parse (cdata, rcdata, ignore), the input level
  265.   // at which the special parse started.
  266.   unsigned specialParseInputLevel_;
  267.   Mode specialParseMode_;
  268.   unsigned markedSectionLevel_;
  269.   unsigned markedSectionSpecialLevel_;
  270.   Vector<Location> markedSectionStartLocation_;
  271.   ConstPtr<Recognizer> recognizers_[nModes];
  272.   XcharMap<PackedBoolean> normalMap_;
  273.   unsigned inputLevel_;
  274.   IList<InputSource> inputStack_;
  275.   Vector<unsigned> inputLevelElementIndex_;
  276.   Ptr<Dtd> currentDtd_;
  277.   ConstPtr<Dtd> currentDtdConst_;
  278.   Vector<Ptr<Dtd> > dtd_;
  279.   Ptr<Dtd> pass1Dtd_;
  280.   ConstPtr<Syntax> syntax_;
  281.   Vector<StringC> currentRank_;
  282.   NamedTable<Id> idTable_;
  283.   NamedResourceTable<Entity> instanceDefaultedEntityTable_;
  284.   NamedResourceTable<Entity> undefinedEntityTable_;
  285.   Vector<ConstPtr<AttributeValue> > currentAttributes_;
  286.   Markup *currentMarkup_;
  287.   Markup markup_;
  288.   Location markupLocation_;
  289.   Boolean hadAfdrDecl_;
  290.   Boolean implydefElement_;
  291.   Boolean implydefAttlist_;
  292.   const volatile sig_atomic_t *cancelPtr_;
  293.   static sig_atomic_t dummyCancel_;
  294.   static const Location nullLocation_;
  295. };
  296.  
  297. inline
  298. Messenger &ParserState::messenger()
  299. {
  300.   return *this;
  301. }
  302.  
  303. inline
  304. Boolean ParserState::wantMarkup() const
  305. {
  306.   return (inInstance_
  307.       ? options_.eventsWanted.wantInstanceMarkup()
  308.       : options_.eventsWanted.wantPrologMarkup());
  309. }
  310.  
  311.  
  312.  
  313. inline
  314. const EventsWanted &ParserState::eventsWanted() const
  315. {
  316.   return options_.eventsWanted;
  317. }
  318.  
  319. inline
  320. InputSource *ParserState::currentInput() const
  321. {
  322.   return inputStack_.head();
  323. }
  324.  
  325. inline
  326. const Location &ParserState::currentLocation() const
  327. {
  328.   InputSource *in = currentInput();
  329.   return in ? in->currentLocation() : nullLocation_;
  330. }
  331.  
  332. inline
  333. Boolean ParserState::pcdataRecovering() const
  334. {
  335.   return pcdataRecovering_;
  336. }
  337.  
  338. inline
  339. unsigned ParserState::inputLevel() const
  340. {
  341.   return inputLevel_;
  342. }
  343.  
  344. inline
  345. unsigned ParserState::specialParseInputLevel() const
  346. {
  347.   return specialParseInputLevel_;
  348. }
  349.  
  350. inline
  351. unsigned ParserState::markedSectionLevel() const
  352. {
  353.   return markedSectionLevel_;
  354. }
  355.  
  356. inline
  357. unsigned ParserState::markedSectionSpecialLevel() const
  358. {
  359.   return markedSectionSpecialLevel_;
  360. }
  361.  
  362. inline
  363. const Location &ParserState::currentMarkedSectionStartLocation() const
  364. {
  365.   return markedSectionStartLocation_.back();
  366. }
  367.  
  368. inline
  369. unsigned ParserState::currentInputElementIndex() const
  370. {
  371.   return inputLevelElementIndex_.back();
  372. }
  373.  
  374. inline
  375. Char ParserState::currentChar() const
  376. {
  377.   return currentInput()->currentTokenStart()[0];
  378. }
  379.  
  380. inline
  381. StringC ParserState::currentToken() const
  382. {
  383.   return StringC(currentInput()->currentTokenStart(),
  384.          currentInput()->currentTokenLength());
  385. }
  386.  
  387. inline
  388. void ParserState::getCurrentToken(StringC &str) const
  389. {
  390.   InputSource *in = currentInput();
  391.   str.assign(in->currentTokenStart(), in->currentTokenLength());
  392. }
  393.  
  394. inline
  395. void ParserState::setRecognizer(Mode mode, ConstPtr<Recognizer> p)
  396. {
  397.   recognizers_[mode] = p;
  398. }
  399.  
  400. inline
  401. void ParserState::setNormalMap(const XcharMap<PackedBoolean> &map)
  402. {
  403.   normalMap_ = map;
  404. }
  405.  
  406. inline
  407. const XcharMap<PackedBoolean> &ParserState::normalMap() const
  408. {
  409.   return normalMap_;
  410. }
  411.  
  412. inline
  413. Boolean ParserState::haveDefLpd() const
  414. {
  415.   return !defLpd_.isNull();
  416. }
  417.  
  418. inline
  419. Boolean ParserState::haveCurrentDtd() const
  420. {
  421.   return !currentDtd_.isNull();
  422. }
  423.  
  424. inline
  425. Dtd &ParserState::defDtd()
  426. {
  427.   return *defDtd_;
  428. }
  429.  
  430. inline
  431. const Dtd &ParserState::currentDtd() const
  432. {
  433.   return *currentDtd_;
  434. }
  435.  
  436. inline
  437. Dtd &ParserState::currentDtdNonConst() const
  438. {
  439.   return *currentDtd_;
  440. }
  441.  
  442. inline
  443. const Ptr<Dtd> &ParserState::defDtdPointer() const
  444. {
  445.   return defDtd_;
  446. }
  447.  
  448. inline
  449. const ConstPtr<Dtd> &ParserState::currentDtdPointer() const
  450. {
  451.   return currentDtdConst_;
  452. }
  453.  
  454. inline
  455. Boolean ParserState::inInstance() const
  456. {
  457.   return inInstance_;
  458. }
  459.  
  460. inline
  461. const Syntax &ParserState::syntax() const
  462. {
  463.   return *syntax_;
  464. }
  465.  
  466. inline
  467. const Syntax &ParserState::instanceSyntax() const
  468. {
  469.   return *instanceSyntax_;
  470. }
  471.  
  472. inline
  473. const ConstPtr<Syntax> &ParserState::syntaxPointer() const
  474. {
  475.   return syntax_;
  476. }
  477.  
  478. inline
  479. const ConstPtr<Syntax> &ParserState::instanceSyntaxPointer() const
  480. {
  481.   return instanceSyntax_;
  482. }
  483.  
  484. inline
  485. const ConstPtr<Syntax> &ParserState::prologSyntaxPointer() const
  486. {
  487.   return prologSyntax_;
  488. }
  489.  
  490. inline
  491. const Sd &ParserState::sd() const
  492. {
  493.   return *sd_;
  494. }
  495.  
  496. inline
  497. const ConstPtr<Sd> &ParserState::sdPointer() const
  498. {
  499.   return sd_;
  500. }
  501.  
  502. inline
  503. void ParserState::setPhase(Phase phase)
  504. {
  505.   phase_ = phase;
  506. }
  507.  
  508. inline
  509. Mode ParserState::currentMode() const
  510. {
  511.   return currentMode_;
  512. }
  513.  
  514. inline
  515. Xchar ParserState::getChar()
  516. {
  517.   return inputStack_.head()->get(messenger());
  518. }
  519.  
  520. inline
  521. void ParserState::skipChar()
  522. {
  523.   (void)getChar();
  524. }
  525.  
  526. inline
  527. Token ParserState::getToken(Mode mode)
  528. {
  529.   return recognizers_[mode]->recognize(inputStack_.head(), messenger());
  530. }
  531.  
  532. inline
  533. Boolean ParserState::hadDtd() const
  534. {
  535.   return dtd_.size() > 0;
  536. }
  537.  
  538. inline
  539. Boolean ParserState::eventQueueEmpty() const
  540. {
  541.   return eventQueue_.empty();
  542. }
  543.  
  544. inline
  545. Event *ParserState::eventQueueGet()
  546. {
  547.   return eventQueue_.get();
  548. }
  549.  
  550. inline
  551. ParserState::Phase ParserState::phase() const
  552. {
  553.   return phase_;
  554. }
  555.  
  556. inline
  557. ParserState::Phase ParserState::finalPhase() const
  558. {
  559.   return finalPhase_;
  560. }
  561.  
  562. inline
  563. EntityManager &ParserState::entityManager() const
  564. {
  565.   return *entityManager_;
  566. }
  567.  
  568. inline
  569. Ptr<EntityManager> ParserState::entityManagerPtr() const
  570. {
  571.   return entityManager_;
  572. }
  573.  
  574. inline
  575. const EntityCatalog &ParserState::entityCatalog() const
  576. {
  577.   return *entityCatalog_;
  578. }
  579.  
  580. inline
  581. ConstPtr<EntityCatalog> ParserState::entityCatalogPtr() const
  582. {
  583.   return entityCatalog_;
  584. }
  585.  
  586. inline
  587. void ParserState::setEntityCatalog(const ConstPtr<EntityCatalog> &catalog)
  588. {
  589.   entityCatalog_ = catalog;
  590. }
  591.  
  592. inline
  593. void ParserState::setDsEntity(const ConstPtr<Entity> &entity)
  594. {
  595.   dsEntity_ = entity;
  596. }
  597.  
  598. inline
  599. Allocator &ParserState::eventAllocator()
  600. {
  601.   return eventAllocator_;
  602. }
  603.  
  604. inline
  605. Allocator &ParserState::internalAllocator()
  606. {
  607.   return internalAllocator_;
  608. }
  609.  
  610. inline
  611. StringC &ParserState::nameBuffer()
  612. {
  613.   return nameBuffer_;
  614. }
  615.  
  616. inline
  617. void ParserState::setHandler(EventHandler *handler,
  618.                  const volatile sig_atomic_t *cancelPtr)
  619. {
  620.   handler_ = handler;
  621.   cancelPtr_ = cancelPtr ? cancelPtr : &dummyCancel_;
  622. }
  623.  
  624. inline
  625. void ParserState::unsetHandler()
  626. {
  627.   handler_ = &eventQueue_;
  628.   cancelPtr_ = &dummyCancel_;
  629. }
  630.  
  631. inline
  632. void ParserState::queueRe(const Location &location)
  633. {
  634.   outputState_.handleRe(*handler_, eventAllocator_, options_.eventsWanted,
  635.             syntax().standardFunction(Syntax::fRE),
  636.             location);
  637. }
  638.  
  639. inline
  640. void ParserState::noteMarkup()
  641. {
  642.   if (inInstance_)
  643.     outputState_.noteMarkup(*handler_, eventAllocator_, options_.eventsWanted);
  644. }
  645.  
  646. inline
  647. void ParserState::noteRs()
  648. {
  649.   outputState_.noteRs(*handler_, eventAllocator_, options_.eventsWanted);
  650. }
  651.  
  652. inline
  653. void ParserState::noteStartElement(Boolean included)
  654. {
  655.   outputState_.noteStartElement(included, *handler_, eventAllocator_,
  656.                 options_.eventsWanted);
  657. }
  658.  
  659. inline
  660. void ParserState::noteEndElement(Boolean included)
  661. {
  662.   outputState_.noteEndElement(included, *handler_, eventAllocator_,
  663.                   options_.eventsWanted);
  664. }
  665.  
  666. inline
  667. void ParserState::noteData()
  668. {
  669.   outputState_.noteData(*handler_, eventAllocator_, options_.eventsWanted);
  670. }
  671.  
  672. inline
  673. unsigned ParserState::subdocLevel() const
  674. {
  675.   return subdocLevel_;
  676. }
  677.  
  678. inline
  679. EventHandler &ParserState::eventHandler()
  680. {
  681.   return *handler_;
  682. }
  683.  
  684. inline
  685. ParserState::IdTableIter ParserState::idTableIter()
  686. {
  687.   // Avoid use of typedef to work around MSVC 2.0 bug.
  688.   return NamedTableIter<Id>(idTable_);
  689. }
  690.  
  691. inline
  692. const ParserOptions &ParserState::options() const
  693. {
  694.   return options_;
  695. }
  696.  
  697. inline
  698. Boolean ParserState::implydefElement()
  699. {
  700.   return implydefElement_;
  701. }
  702.  
  703. inline
  704. Boolean ParserState::implydefAttlist()
  705. {
  706.   return implydefAttlist_;
  707. }
  708.  
  709. inline
  710. void ParserState::enableImplydef()
  711. {
  712.   implydefElement_ = 1;
  713.   implydefAttlist_ = 1;
  714. }
  715.  
  716. inline
  717. void ParserState::keepMessages()
  718. {
  719.   keepingMessages_ = 1;
  720. }
  721.  
  722. inline
  723. Boolean ParserState::haveApplicableDtd() const
  724. {
  725.   return !currentDtd_.isNull();
  726. }
  727.  
  728. inline
  729. Boolean ParserState::hadLpd() const
  730. {
  731.   return hadLpd_;
  732. }
  733.  
  734. inline
  735. Boolean ParserState::pass2() const
  736. {
  737.   return pass2_;
  738. }
  739.  
  740. inline
  741. size_t ParserState::nActiveLink() const
  742. {
  743.   return lpd_.size();
  744. }
  745.  
  746. inline
  747. const Lpd &ParserState::activeLpd(size_t i) const
  748. {
  749.   return *lpd_[i];
  750. }
  751.  
  752. inline
  753. Lpd &ParserState::defLpd()
  754. {
  755.   return *defLpd_;
  756. }
  757.  
  758. inline
  759. Ptr<Lpd> &ParserState::defLpdPointer()
  760. {
  761.   return defLpd_;
  762. }
  763.  
  764. inline
  765. Ptr<ComplexLpd> ParserState::defComplexLpdPointer()
  766. {
  767.   return (ComplexLpd *)defLpd_.pointer();
  768. }
  769.  
  770. inline
  771. ComplexLpd &ParserState::defComplexLpd()
  772. {
  773.   return (ComplexLpd &)defLpd();
  774. }
  775.  
  776. inline
  777. Ptr<Dtd> ParserState::baseDtd() 
  778. {
  779.   if (dtd_.size() > 0)
  780.     return dtd_[0];
  781.   else
  782.     return Ptr<Dtd>();
  783. }
  784.  
  785. inline
  786. void ParserState::setResultAttributeSpecMode()
  787. {
  788.   resultAttributeSpecMode_ = 1;
  789. }
  790.  
  791. inline
  792. void ParserState::clearResultAttributeSpecMode()
  793. {
  794.   resultAttributeSpecMode_ = 0;
  795. }
  796.  
  797. inline
  798. Markup *ParserState::currentMarkup()
  799. {
  800.   return currentMarkup_;
  801. }
  802.  
  803. inline
  804. const Location &ParserState::markupLocation() const
  805. {
  806.   return markupLocation_;
  807. }
  808.  
  809. inline
  810. Markup *ParserState::startMarkup(Boolean storing, const Location &loc)
  811. {
  812.   markupLocation_ = loc;
  813.   if (storing) {
  814.     markup_.clear();
  815.     return currentMarkup_ = &markup_;
  816.   }
  817.   else
  818.     return currentMarkup_ = 0;
  819. }
  820.  
  821. inline
  822. Boolean ParserState::cancelled() const
  823. {
  824.   return *cancelPtr_ != 0;
  825. }
  826.  
  827. inline
  828. void ParserState::setHadAfdrDecl()
  829. {
  830.   hadAfdrDecl_ = 1;
  831. }
  832.  
  833. inline
  834. Boolean ParserState::hadAfdrDecl() const
  835. {
  836.   return hadAfdrDecl_;
  837. }
  838.  
  839. #ifdef SP_NAMESPACE
  840. }
  841. #endif
  842.  
  843. #endif /* not ParserState_INCLUDED */
  844.